                Computer graphics systems typically utilize instructions, implemented via a graphics program on a computer system, to specify calculations and operations needed to produce two-dimensional or three-dimensional displays. Exemplary graphics systems that include APIs that are commercially available for rendering three-dimensional graphs include Direct3D, available from Microsoft Corporation, of Redmond, Wash., and OpenGL by Silicon Graphics, Inc., of Mountain View, Calif.        
Computer graphics systems can be envisioned as a pipeline through which data pass, where the data are used to define an image that is to be produced and displayed. At various points along the pipeline, various calculations and operations that are specified by a graphics designer are used to operate upon and modify the data.
In the initial stages of the pipeline, the desired image is described by the application using geometric shapes such as lines and polygons, referred to in the art as “geometric primitives.” The derivation of the vertices for an image and the manipulation of the vertices to provide animation entail performing numerous geometric calculations in order to eventually project the three-dimensional world being synthesized to a position in the two-dimensional world of the display screen.
Primitives are constructed out of “fragments.” These fragments have attributes calculated, such as color and depth. In order to enhance the quality of the image, effects such as lighting, fog, and shading are added, and anti-aliasing and blending functions are used to give the image a more realistic appearance. The processes pertaining to per fragment calculation of colors, depth, texturing, lighting, etc., are collectively known as “rasterization”.
The fragments and their associated attributes are stored in a frame buffer. Once rasterization of the entire frame has been completed, pixel color values can then be read from the frame buffer and used to draw images on the computer screen.
To assist in understanding a typical computer graphics system, consider FIG. 1 which illustrates, generally at 100, a system that can implement a computer graphics process. System 100 comprises a graphics front end 102, a geometry engine 104, a rasterization engine 106, and a frame buffer 108. System 100 can typically be implemented in hardware, software, firmware or combinations thereof, and is also referred to as a “rendering pipeline”.
Graphics front end 102 comprises, in this example, an application, primitive data generation stage 102a and display list generation stage 102b. The graphics front end generates geographic primitive data consumed by the subsequent pipeline stage(s). Geographic primitive data is typically loaded from a computer system's memory and saved in a display list in the display list stage 102b. All geometric primitives are eventually described by vertices or points.
Geometry engine 104 comprises, in this example, high order surface (HOS) tessellation 104a, and per-vertex operations stage 104b. In stage 104a, primitive data is converted into simple rasterizer-supported primitives (typically triangles) that represent the surfaces that are to be graphically displayed. Some vertex data (for example, spatial coordinates) are transformed by four-by-four floating point matrices to project the spatial coordinates from a position in the three-dimensional world to a position on the display screen. In addition, certain other advanced features can also be performed by this stage. Texturing coordinates may be generated and transformed. Lighting calculations can be performed using the vertex, the surface normal, material properties, and other light information to produce a color value. Perspective division, which is used to make distant objects appear smaller than closer objects in the display, can also occur in per-vertex operations stage 104b. 
Rasterization engine 106 is configured to perform so-called rasterization of the re-assembled rasterizer-supported primitives. It comprises the following stages: triangle/point assembly 106a, setup 106b, parametric evaluation 106c, depth and stencil operations stage 106d, per-fragment operations stage 106e, and the blend and raster operations (ROP) stage 106f. 
Rasterization refers to the conversion of vertex data connected as rasterizer-supported primitives into “fragments.” Each fragment corresponds to a single element (e.g., a “pixel” or “sub-pixel”) in the graphics display, and typically includes data defining color, transparency, depth, and texture(s). Thus, for a single fragment, there are typically multiple pieces of data defining that fragment. To perform its functions, triangle/point assembly stage 106a fetches different vertex components, such as one or multiple texture component(s), a color component, a depth component, and an alpha blending component (which typically represents transparency).
Setup stage 106b converts the vertex data into parametric function coefficients that can then be evaluated on a fragment coordinate (either pixel or sub-pixel) by fragment coordinate basis. Parametric evaluation stage 106c evaluates the parametric functions for all the fragments which lie within the given rasterizable primitive, while conforming to rasterizable primitive inclusion rules and contained within the frame buffer extents.
Depth and stencil operations stage 106d perform depth operations on the projected fragment depth and application specified fragment stencil operations. These operations apply to both the comparison function on the depth and stencil values, how the depth and stencil values should be updated in the depth/stencil buffer and whether the fragment should terminate or continue processing. In the idealized rasterization pipeline these operations take place just before frame buffer write-back (after blend and ROP stage 106f), but commonly these operations are valid before the per-fragment operations stage 106e, which enables early termination of many fragments and corresponding performance optimizations/improvements.
Per-fragment operations stage 106e typically performs additional operations that may be enabled to enhance the detail or lighting effects of the fragments, such as texturing, bump mapping, per-fragment lighting, fogging, and other like operations. Near the end of the rasterization pipeline is the blend and raster operation (ROP) stage 106f, which implements blending for transparency effects and traditional 2D blit raster operations. After completion of these operations, the processing of the fragment is complete and it is typically written to frame buffer 110 and potentially to the depth/stencil buffer 108. Thus, there are typically multiple pieces of data defining each pixel.
Now consider FIG. 2 which is a further embellishment of certain component in rasterization engine 106 In this example, rasterization engine 106 comprises, among other elements, a texture component 200, a specular component 202, a fog component 204 and an alpha blending component 206, each of which is configured to process fragment or pixel data to achieve a desired effect.
Specifically, texture component 200 implements texturing techniques and processes the pixel data to effect how the surface of an object or image appears. This can be done, for example, by using a one- or a two-dimensional image to mathematically modify the pixel data to achieve a desired effect. Specular component 202 implements specular lighting techniques and processes the pixel data to incorporate specular lighting effects. Fog component 204 processes the pixel data and implements a rendering technique that is used to simulate atmospheric effects such as haze, fog, and smog by fading object colors to a background color based on distance from the viewer. Fog also aids in the perception of distance from the viewer, giving a depth cue. Alpha blending component 206 implements techniques that process the pixel data to affect the opacity or transparency of the ultimately rendered pixel.
Typically, with respect to components 200-206, there is a whole menu of operations that can be performed by each individual component, and the system can select from this menu of operations and process the pixel data accordingly.
In the past, graphics systems have provided individual components, such as components 200-206, in a graphics pipeline in a fixed static order, the effect of which is to define the order in which the pixel data is processed. That is, the order in which the pixel data is processed in these systems and by these components is fixed and typically does not vary. For example, assume that all of the components are enabled for a particular amount of pixel data that is to be processed. In accordance with these past systems, the pixel data would first processed by the texture component to have a texture applied. After application of the texture, the pixel data would processed by the specular component to have specular lighting effects applied. Next, the pixel data would be processed by the fog component to have fog effects applied. Lastly, the pixel data would be processed by the alpha blending component to have a transparency/opacity effect applied. As an aside, having the alpha blending component as the last component in the pipeline is also a convenient architecture design choice for designers who can then mitigate the effects of a read after write hazard. That is, typically the alpha blending component requires a read operation from the frame buffer. After the alpha component operates on the pixel data, it is then typically written back to the frame buffer. The longer the pipeline is between the read and the write operations, the more likely it is for a read after write hazard to occur.
Systems such as the one described above, that impose a fixed order on the individual components of a rasterization pipeline, can result in rendered objects that do not accurately or correctly appear as they might in real life. For example, in some instances, a more realistic rendered image might be presented to a user if the pixel data associated with an object were able to be processed by the alpha blending component, and then the texture component. Yet, current systems do not allow this to occur. Additionally, having this fixed order of components in the rasterization pipeline can adversely affect the efficiency with which multi-pass algorithms operate on the pixel data.
Accordingly, this invention arose out of concerns associated with providing improved graphics systems and methods.